//        给定一个很长的数组 (长度 1000w), 通过随机数的方式生成 1-100 之间的整数.
//        实现代码, 能够创建两个线程, 对这个数组的所有元素求和.
//        其中线程1 计算偶数下标元素的和, 线程2 计算奇数下标元素的和.
//        最终再汇总两个和, 进行相加
//        记录程序的执行时间.

//              int x=(int)(Math.random()*100+1);
//              Math.random()随机生成区间[0,1)的浮点数，
//              乘以100，区间[0-100),取[1-100],则加1，得[1,101)。
//             由此得公式：math.random()*max+min,[min,max)
//                ————————————————


//public class MyThead {
//    static int indexSum1=0;
//    static int indexSum2=0;
//    public static void main(String[] args) throws InterruptedException {
//        int [] arr= new int[1000000];
//        Random random = new Random();
//        for (int i = 0; i < arr.length; i++) {
//            //arr[i] = (int)(Math.random()*100+1);
//            arr[i] = random.nextInt(100)+1;
//
//        }
//        //记录系统当前时间
//        long begin = System.currentTimeMillis();
//        //进程1返回数组偶数下标元素相加之和
//        Thread t1 = new Thread(()->{
//            for (int i = 0; i < arr.length; i=i+2) {
//                indexSum1 +=arr[i];
//            }
//            System.out.println("进程1:"+indexSum1);
//        });
//        //进程2返回数组下标奇数元素之和
//        Thread t2 = new Thread(()->{
//            for (int i = 1; i < arr.length; i=i+2) {
//                indexSum2 +=arr[i];
//            }
//            System.out.println("进程2:"+indexSum2);
//        });
//        t1.start();
//        t2.start();
//        t1.join();
//        t2.join();
//        //记录完成时间
//        long end = System.currentTimeMillis();
//        System.out.println("数组元素之和sum = "+(indexSum1+indexSum2));
//        System.out.println("执行时间:"+(end-begin));
//    }
//}



//    继承 Thread, 重写 run
//    实现 Runnable, 重写 run
//    继承 Thread, 重写 run, 使用匿名内部类
//    实现 Runnable, 重写 run, 使用匿名内部类
//    使用 lambda 表达式

public class MyThead extends Thread{
    @Override
    public void run() {
        System.out.println("继承 Thread, 重写 run");
    }
}
class MyThead2 implements Runnable{
    @Override
    public void run() {
        System.out.println("实现 Runnable, 重写 run");
    }
}
class MyThead3 extends Thread{

}

 class Test {
     public static void main(String[] args) throws InterruptedException {
         Thread t1= new MyThead();
         t1.start();

         MyThead2 myThead2 = new MyThead2();
         Thread t2 = new Thread(myThead2);
         t2.start();
         Thread t3 = new Thread(new Runnable() {
             @Override
             public void run() {
                 System.out.println("实现 Runnable, 重写 run, 使用匿名内部类");
             }
         });
         t3.start();

         Thread t4 = new Thread(new MyThead3(){
            @Override
             public void run(){
                System.out.println("继承 Thread, 重写 run, 使用匿名内部类");
            }
         });
         t4.start();

         Thread thread = new Thread(()->{
             System.out.println("使用 lambda 表达式");
         });
         thread.start();
     }
}